Enterprise AI Governance Policy Series: Machine Readable Policy Schema Specification

This specification defines the mandatory schema, structural grammar, and compilation requirements for converting natural-language governance constraints into deterministic, machine-readable rules. AI systems cannot safely interpret policy text; governance meaning must be compiled into strict, inspectable, and executable rule structures.

This specification ensures:

• Deterministic encoding of obligations, prohibitions, permissions, and boundaries.
• Stable semantics across updates, vendors, and deployment environments.
• Sovereign, inspectable rule interpretation independent of model behaviour.
• Compatibility with OPA, Cedar, Rego, and other deterministic policy engines.
• Elimination of governance drift caused by natural-language ambiguity.

This specification is binding across all enterprise systems where governance meaning must be enforced at runtime.

This specification applies to all governance constraints that must be enforced deterministically, executed at runtime, audited immutably, and versioned with statutory provenance. Covered constraints include:

2.1 Operational Constraints

• Permitted actions
• Prohibited actions
• Conditional actions
• State-transition rules

2.2 Statutory & Regulatory Constraints

• Legal obligations
• Sector-specific mandates
• Compliance boundaries

2.3 Safety & Domain Constraints

• Clinical safety rules
• Legal notice issuance rules
• Civic administration boundaries
• Financial ceilings

2.4 Agentic & Tool-Calling Constraints

• Tool-calling permissions
• Agentic coordination limits
• Mesh divergence boundaries

If a rule must be enforced, it must be encoded.

3.1 Natural-Language Constraint

A human-authored governance rule describing obligations, prohibitions, or boundaries.

3.2 Deterministic Policy Schema

A structured, machine-readable representation of governance meaning.

3.3 Semantic Atom

The smallest indivisible unit of governance meaning (e.g., “may not initiate payment”).

3.4 Constraint Grammar

The formal grammar used to encode semantic atoms into deterministic structures.

3.5 Policy Compiler

The system that converts natural-language constraints into OPA, Cedar, Rego, or equivalent rule formats.

4.1 One Authoritative Interpretation

Natural-language constraints must compile into a single deterministic meaning.

4.2 Zero Ambiguity

Encoded rules must eliminate ambiguity, vagueness, and interpretive drift.

4.3 Deterministic Execution

Encoded rules must execute identically across environments and updates.

4.4 Semantic Stability

Encoded meaning must remain stable across model versions and vendor changes.

4.5 Immutable Provenance

All encoded rules must be linked to statutory or executive authority.

All constraints must be decomposed into the following semantic atoms:

5.1 Obligations

Rules describing what must occur. Example atom: obligation: { action: "record_audit_log", condition: "on_state_change" }

5.2 Prohibitions

Rules describing what must not occur. Example atom: prohibition: { action: "issue_payment", condition: "unauthorised_identity" }

5.3 Permissions

Rules describing what may occur under defined conditions. Example atom: permission: { action: "access_registry", condition: "role=governance_analyst" }

5.4 Dependencies

Rules describing required preconditions. Example atom: dependency: { action: "execute_tool", requires: "deterministic_gate_approval" }

5.5 State Transitions

Rules describing allowed changes in system state. Example atom: state_transition: { from: "pending", to: "approved", condition: "statutory_compliance=true" }

5.6 Semantic Boundaries

Rules describing domain-specific limits. Example atom: boundary: { domain: "clinical", prohibits: "diagnosis_generation" }

All encoded constraints must follow a strict schema:

rule {
    id: string
    type: obligation | prohibition | permission | dependency | state_transition | boundary
    domain: string
    action: string
    condition: string
    parameters: map<string, any>
    provenance: {
        source: statutory | executive | operational
        reference: string
        version: string
    }
}

This schema is compatible with OPA (Open Policy Agent), Cedar, Rego, deterministic rule engines, and sovereign governance substrates.

• Stage 1: Semantic Extraction: Natural-language constraints are decomposed into semantic atoms.
• Stage 2: Grammar Encoding: Atoms are encoded using the constraint grammar.
• Stage 3: Schema Assembly: Atoms are assembled into machine-readable rule structures.
• Stage 4: Deterministic Compilation: Rules are compiled into OPA, Cedar, Rego, or equivalent formats.
• Stage 5: Runtime Promotion: Compiled rules are deployed to deterministic enforcement gates.
• Stage 6: Immutable Versioning: All rule versions are stored with cryptographic provenance.

Every encoded rule must pass:

• Semantic Integrity Check: Ensures encoded meaning matches natural-language intent.
• Deterministic Execution Check: Ensures rule executes identically across environments.
• Drift Resistance Check: Ensures rule is stable across model updates.
• Provenance Check: Ensures rule is linked to statutory or executive authority.
• Boundary Alignment Check: Ensures rule aligns with domain-specific constraints.

Any failure results in automatic halt + escalation.

9.1 Continuous Schema Validation

Encoded rules must be validated continuously.

9.2 Quarterly Schema Audits

Oversight Layer reviews rule drift, semantic stability, and provenance.

9.3 Bi-Annual Executive Reviews

Executive Governance Layer recalibrates governance meaning and rule boundaries.

• Stage 1: Trigger: Initiated by statutory amendment, executive directive, operational drift, or Level 3 escalation.
• Stage 2: Semantic Authoring: Policy Owner + Domain Lead update natural-language constraints.
• Stage 3: Deterministic Compilation: Engineering compiles updated constraints into machine-readable rules.
• Stage 4: Sandbox Simulation: Validation against historical telemetry.
• Stage 5: Promotion & Rollback: Deployment with automated rollback if regression occurs.

Systems must maintain:

11.1 Immutable Rule Logs

Recording rule evaluations, rule failures, and rule provenance.

11.2 Schema Versioning

Historical records linking every rule to its statutory mandate.

11.3 Compilation Reports

Comprehensive records of rule compilation + validation outcomes.

11.4 Statutory Alignment Mapping

Demonstrating compliance with EU AI Act, DORA, NIST AI RMF, and ISO/IEC 42001.

Machine-readable schemas preserve governance meaning. Deterministic compilation preserves operational safety.

All AI systems must operate under:

• Deterministic rule encoding
• Sovereign rule interpretation
• Immutable provenance
• Continuous schema validation